JustAcademy Selenium Training: JustAcademy Selenium Training Course
JustAcademy Demo Registration: Register for Selenium Course Demo
Expected Conditions are predefined conditions provided by Selenium that are commonly used with explicit waits to synchronize automated test execution with the current state of a web application. Instead of making Selenium wait for a fixed amount of time, Expected Conditions allow the script to wait for a specific condition such as an element becoming visible, clickable, selected, present, invisible, or containing specific text.
Expected Conditions are especially important when testing modern web applications where elements can be loaded or updated asynchronously through JavaScript, AJAX requests, API calls, animations, dynamic DOM changes, and other browser-side operations.
JustAcademy's Selenium curriculum includes waits, synchronization, and dynamic elements, including implicit wait, explicit wait, Fluent Wait, page-load synchronization, handling dynamic elements, and stable test execution strategies. Selenium Training Course | Selenium Course Demo
Expected Conditions are ready-to-use conditions that can be passed to Selenium's explicit wait mechanism. They help the automation script wait until a particular state is achieved before continuing with the next operation.
WebDriverWait wait = new WebDriverWait(driver, Duration.ofSeconds(10));
WebElement username = wait.until(
ExpectedConditions.visibilityOfElementLocated(By.id("username")));
In this example, Selenium waits until the username element is visible before returning the WebElement.
Selenium commands can execute faster than a web application can update its user interface. A page may still be loading, an AJAX request may still be running, a button may still be disabled, or a dynamic element may not yet exist in the DOM.
Without proper synchronization, Selenium tests can fail even when the application is functioning correctly.
Test Starts
↓
Open Application
↓
Application Loads
↓
JavaScript Executes
↓
API/AJAX Request
↓
DOM Updates
↓
Element Becomes Ready
↓
Selenium Performs Action
Expected Conditions are most commonly used with WebDriverWait, which provides explicit waiting for a particular condition.
WebDriverWait wait = new WebDriverWait(driver, Duration.ofSeconds(10));
wait.until(ExpectedConditions.visibilityOfElementLocated(By.id("login")));
The wait checks the specified condition until it succeeds or the maximum timeout is reached.
import java.time.Duration;
import org.openqa.selenium.By;
import org.openqa.selenium.WebDriver;
import org.openqa.selenium.WebElement;
import org.openqa.selenium.Alert;
import org.openqa.selenium.support.ui.ExpectedConditions;
import org.openqa.selenium.support.ui.WebDriverWait;
WebDriverWait wait = new WebDriverWait(driver, Duration.ofSeconds(10));
WebElement element = wait.until(
ExpectedConditions.visibilityOfElementLocated(
By.id("username")));
Create WebDriverWait
↓
Set Maximum Timeout
↓
Specify Expected Condition
↓
Check Condition
↓
Condition Satisfied?
/ \
Yes No
↓ ↓
Continue Check Again
↓
Timeout Reached?
/ \
No Yes
↓ ↓
Repeat TimeoutException
Selenium provides the ExpectedConditions class containing commonly used conditions for synchronizing browser automation.
| Expected Condition | Purpose |
|---|---|
| presenceOfElementLocated() | Waits for an element to be present in the DOM. |
| visibilityOfElementLocated() | Waits for an element to be located and visible. |
| visibilityOf() | Waits for an existing WebElement to become visible. |
| elementToBeClickable() | Waits for an element to be visible and enabled. |
| invisibilityOfElementLocated() | Waits for an element to become invisible or unavailable. |
| textToBePresentInElementLocated() | Waits for specific text to appear. |
| textToBePresentInElement() | Waits for specific text in an existing element. |
| attributeToBe() | Waits for an attribute to have a specific value. |
| attributeContains() | Waits for an attribute to contain specific text. |
| elementToBeSelected() | Waits for an element to become selected. |
| elementSelectionStateToBe() | Waits for a selected or unselected state. |
| alertIsPresent() | Waits for a JavaScript alert. |
| frameToBeAvailableAndSwitchToIt() | Waits for a frame and switches into it. |
| stalenessOf() | Waits for an old element to become detached from the DOM. |
| titleContains() | Waits for text to appear in the page title. |
| titleIs() | Waits for the exact page title. |
| urlContains() | Waits for text to appear in the URL. |
| urlToBe() | Waits for the URL to exactly match a value. |
| numberOfWindowsToBe() | Waits for a specific number of browser windows or tabs. |
presenceOfElementLocated() waits until an element is present in the DOM. The element does not necessarily need to be visible.
WebElement element = wait.until(
ExpectedConditions.presenceOfElementLocated(
By.id("username")));
WebElement searchBox = wait.until(
ExpectedConditions.presenceOfElementLocated(
By.id("search")));
searchBox.sendKeys("Selenium");
| Presence | Visibility |
|---|---|
| Element exists in the DOM. | Element is displayed. |
| Element may still be hidden. | Element is rendered and has meaningful dimensions. |
| Useful when DOM existence is enough. | Useful before visible interaction. |
| Does not guarantee user visibility. | Does not automatically guarantee successful clicking. |
visibilityOfElementLocated() waits until the element can be located and is visible.
WebElement username = wait.until(
ExpectedConditions.visibilityOfElementLocated(
By.id("username")));
username.sendKeys("admin");
visibilityOf() is useful when the WebElement has already been located and the test needs to wait until it becomes visible.
WebElement message = driver.findElement(By.id("message"));
WebElement visibleMessage = wait.until(
ExpectedConditions.visibilityOf(message));
| Method | Input | Purpose |
|---|---|---|
| visibilityOfElementLocated() | By locator | Locates and waits for visibility. |
| visibilityOf() | WebElement | Waits for an already located element to become visible. |
elementToBeClickable() waits until an element is visible and enabled. It is commonly used before clicking buttons, links, checkboxes, menus, and other interactive controls.
WebElement loginButton = wait.until(
ExpectedConditions.elementToBeClickable(
By.id("login")));
loginButton.click();
For Selenium's expected condition, an element is considered clickable when it is visible and enabled. This condition does not guarantee that a click will always succeed because another element, overlay, animation, layout change, or dynamic DOM update may still interfere.
WebElement button = driver.findElement(By.id("submit"));
WebElement clickableButton = wait.until(
ExpectedConditions.elementToBeClickable(button));
clickableButton.click();
invisibilityOfElementLocated() is useful when the test needs to wait until a temporary element such as a loader, spinner, overlay, or progress indicator becomes invisible or is no longer present.
wait.until(
ExpectedConditions.invisibilityOfElementLocated(
By.id("loader")));
wait.until(
ExpectedConditions.invisibilityOfElementLocated(
By.cssSelector(".loading-spinner")));
WebElement dashboard = wait.until(
ExpectedConditions.visibilityOfElementLocated(
By.id("dashboard")));
This condition waits until the specified text is present inside an element located by the given locator.
wait.until(
ExpectedConditions.textToBePresentInElementLocated(
By.id("status"),
"Completed"));
wait.until(
ExpectedConditions.textToBePresentInElementLocated(
By.id("orderStatus"),
"Delivered"));
System.out.println("Order completed");
This condition can be used when the WebElement has already been located.
WebElement message = driver.findElement(By.id("message"));
wait.until(
ExpectedConditions.textToBePresentInElement(
message,
"Success"));
This condition can be used to wait until the value of a form element contains the expected text.
wait.until(
ExpectedConditions.textToBePresentInElementValue(
By.id("search"),
"Selenium"));
attributeToBe() waits until an element's specified attribute has the expected value.
wait.until(
ExpectedConditions.attributeToBe(
By.id("status"),
"data-state",
"complete"));
attributeContains() waits until an attribute contains a specified value.
wait.until(
ExpectedConditions.attributeContains(
By.id("order"),
"class",
"completed"));
wait.until(
ExpectedConditions.attributeContains(
By.id("submit"),
"class",
"active"));
elementToBeSelected() waits until an element becomes selected. It is useful for checkboxes, radio buttons, and selectable elements.
wait.until(
ExpectedConditions.elementToBeSelected(
By.id("terms")));
elementSelectionStateToBe() waits until an element reaches the specified selected or unselected state.
wait.until(
ExpectedConditions.elementSelectionStateToBe(
By.id("terms"),
true));
wait.until(
ExpectedConditions.elementSelectionStateToBe(
By.id("terms"),
true));
wait.until(
ExpectedConditions.elementSelectionStateToBe(
By.id("subscribe"),
false));
alertIsPresent() waits until a JavaScript alert is present.
Alert alert = wait.until(
ExpectedConditions.alertIsPresent());
alert.accept();
driver.findElement(By.id("delete")).click();
Alert alert = wait.until(
ExpectedConditions.alertIsPresent());
System.out.println(alert.getText());
alert.accept();
Alert alert = wait.until(
ExpectedConditions.alertIsPresent());
if (alert.getText().contains("Are you sure")) {
alert.accept();
}
frameToBeAvailableAndSwitchToIt() waits until a frame becomes available and switches the WebDriver context into that frame.
wait.until(
ExpectedConditions.frameToBeAvailableAndSwitchToIt(
By.id("paymentFrame")));
driver.findElement(By.id("cardNumber"))
.sendKeys("1234");
wait.until(
ExpectedConditions.frameToBeAvailableAndSwitchToIt(
By.id("paymentFrame")));
driver.findElement(By.id("cardNumber"))
.sendKeys("1234");
driver.switchTo().defaultContent();
stalenessOf() waits until a previously located WebElement is no longer attached to the current DOM.
WebElement oldElement = driver.findElement(
By.id("dynamicElement"));
driver.findElement(By.id("refresh")).click();
wait.until(
ExpectedConditions.stalenessOf(oldElement));
Modern web applications may replace existing DOM elements after an action. The original WebElement can then become stale. Waiting for the old element to become stale can help synchronize the test before locating the newly rendered element.
titleContains() waits until the browser page title contains specified text.
wait.until(
ExpectedConditions.titleContains("Dashboard"));
titleIs() waits until the page title exactly matches the expected title.
wait.until(
ExpectedConditions.titleIs("Dashboard - Home"));
urlContains() waits until the current URL contains the specified text.
wait.until(
ExpectedConditions.urlContains("/dashboard"));
urlToBe() waits until the current URL exactly matches the expected URL.
wait.until(
ExpectedConditions.urlToBe(
"https://example.com/dashboard"));
urlMatches() can be used when the URL needs to match a regular expression pattern.
wait.until(
ExpectedConditions.urlMatches(
".*/dashboard.*"));
numberOfWindowsToBe() waits until the browser has the specified number of windows or tabs.
String parentWindow = driver.getWindowHandle();
driver.findElement(By.id("openWindow")).click();
wait.until(
ExpectedConditions.numberOfWindowsToBe(2));
wait.until(
ExpectedConditions.numberOfWindowsToBe(2));
for (String handle : driver.getWindowHandles()) {
if (!handle.equals(parentWindow)) {
driver.switchTo().window(handle);
break;
}
}
presenceOfAllElementsLocatedBy() waits until matching elements are present in the DOM and returns the collection of matching elements.
List<WebElement> products = wait.until(
ExpectedConditions.presenceOfAllElementsLocatedBy(
By.cssSelector(".product")));
visibilityOfAllElementsLocatedBy() waits until all matching elements are visible.
List<WebElement> products = wait.until(
ExpectedConditions.visibilityOfAllElementsLocatedBy(
By.cssSelector(".product")));
This condition can be used when a collection of WebElements has already been located and the test needs to wait for their visibility.
List<WebElement> products =
driver.findElements(By.cssSelector(".product"));
wait.until(
ExpectedConditions.visibilityOfAllElements(products));
Expected Conditions are particularly useful when working with dynamic applications where the state of the page changes after user actions or background operations.
wait.until(
ExpectedConditions.visibilityOfElementLocated(
By.id("ajaxResult")));
Instead of using a fixed delay, the test waits for the UI state that indicates the AJAX operation has produced its result.
driver.findElement(By.id("search"))
.sendKeys("Selenium");
driver.findElement(By.id("searchButton")).click();
List<WebElement> results = wait.until(
ExpectedConditions.visibilityOfAllElementsLocatedBy(
By.cssSelector(".search-result")));
WebElement submit = wait.until(
ExpectedConditions.elementToBeClickable(
By.id("submit")));
submit.click();
wait.until(
ExpectedConditions.invisibilityOfElementLocated(
By.cssSelector(".spinner")));
WebElement result = wait.until(
ExpectedConditions.visibilityOfElementLocated(
By.id("result")));
WebElement modal = wait.until(
ExpectedConditions.visibilityOfElementLocated(
By.id("confirmationModal")));
WebElement confirm = wait.until(
ExpectedConditions.elementToBeClickable(
By.id("confirm")));
confirm.click();
driver.findElement(By.id("username"))
.sendKeys("admin");
driver.findElement(By.id("password"))
.sendKeys("admin123");
wait.until(
ExpectedConditions.elementToBeClickable(
By.id("login"))).click();
wait.until(
ExpectedConditions.visibilityOfElementLocated(
By.id("dashboard")));
wait.until(
ExpectedConditions.elementToBeClickable(
By.id("addToCart"))).click();
wait.until(
ExpectedConditions.attributeContains(
By.id("cart"),
"data-count",
"1"));
wait.until(
ExpectedConditions.elementToBeClickable(
By.id("checkout"))).click();
wait.until(
ExpectedConditions.visibilityOfElementLocated(
By.id("paymentPage")));
wait.until(
ExpectedConditions.elementToBeClickable(
By.id("register"))).click();
wait.until(
ExpectedConditions.visibilityOfElementLocated(
By.id("registrationSuccess")));
import org.testng.Assert;
import org.testng.annotations.Test;
@Test
public void verifyDashboard() {
WebElement dashboard = wait.until(
ExpectedConditions.visibilityOfElementLocated(
By.id("dashboard")));
Assert.assertTrue(dashboard.isDisplayed());
}
public class LoginPage {
private WebDriver driver;
private WebDriverWait wait;
private By username = By.id("username");
private By password = By.id("password");
private By loginButton = By.id("login");
private By dashboard = By.id("dashboard");
public LoginPage(WebDriver driver) {
this.driver = driver;
this.wait = new WebDriverWait(
driver,
Duration.ofSeconds(10));
}
public void login(String user, String pass) {
wait.until(
ExpectedConditions.visibilityOfElementLocated(
username)).sendKeys(user);
wait.until(
ExpectedConditions.visibilityOfElementLocated(
password)).sendKeys(pass);
wait.until(
ExpectedConditions.elementToBeClickable(
loginButton)).click();
}
public boolean isDashboardDisplayed() {
return wait.until(
ExpectedConditions.visibilityOfElementLocated(
dashboard)).isDisplayed();
}
}
public class WaitUtils {
private WebDriverWait wait;
public WaitUtils(WebDriver driver) {
wait = new WebDriverWait(
driver,
Duration.ofSeconds(10));
}
public WebElement waitForVisible(By locator) {
return wait.until(
ExpectedConditions.visibilityOfElementLocated(
locator));
}
public WebElement waitForClickable(By locator) {
return wait.until(
ExpectedConditions.elementToBeClickable(
locator));
}
public void waitForInvisible(By locator) {
wait.until(
ExpectedConditions.invisibilityOfElementLocated(
locator));
}
}
WaitUtils waitUtils = new WaitUtils(driver);
WebElement username =
waitUtils.waitForVisible(By.id("username"));
username.sendKeys("admin");
waitUtils.waitForClickable(
By.id("login")).click();
When Selenium's predefined conditions do not exactly match the application's state, a custom lambda condition can be used with wait.until().
Boolean completed = wait.until(driver -> {
WebElement status = driver.findElement(By.id("status"));
return "Completed".equals(status.getText());
});
Boolean enabled = wait.until(driver -> {
return driver.findElement(By.id("submit")).isEnabled();
});
If the requirement is both visibility and enabled state before clicking, elementToBeClickable() is often a more appropriate condition.
List<WebElement> products = wait.until(driver -> {
List<WebElement> elements =
driver.findElements(By.cssSelector(".product"));
return elements.size() >= 5 ? elements : null;
});
If the required condition is not satisfied before the configured timeout expires, Selenium's explicit wait fails with a TimeoutException.
try {
wait.until(
ExpectedConditions.visibilityOfElementLocated(
By.id("result")));
} catch (TimeoutException e) {
System.out.println(
"Element did not become visible");
throw e;
}
Dynamic applications can replace DOM elements. If a previously stored WebElement is replaced, the reference can become stale.
WebElement oldElement = driver.findElement(
By.id("dynamic"));
driver.findElement(By.id("refresh")).click();
wait.until(
ExpectedConditions.stalenessOf(oldElement));
WebElement newElement = wait.until(
ExpectedConditions.visibilityOfElementLocated(
By.id("dynamic")));
| Expected Conditions | Thread.sleep() |
|---|---|
| Condition-based synchronization. | Fixed delay. |
| Checks application state. | Does not check application state. |
| Can continue as soon as the condition succeeds. | Always waits the complete duration. |
| Suitable for dynamic applications. | Not a good general synchronization strategy. |
| Provides reusable conditions. | Provides no application-specific condition. |
| Feature | Implicit Wait | Expected Conditions |
|---|---|---|
| Scope | Element lookup. | Specific application state. |
| Visibility | No specific visibility condition. | Supported. |
| Clickability | No. | Supported. |
| Alerts | No. | Supported. |
| Frames | No. | Supported. |
| Text | No. | Supported. |
| Attributes | No. | Supported. |
| Feature | Expected Conditions | Fluent Wait |
|---|---|---|
| Purpose | Predefined synchronization conditions. | Flexible waiting mechanism. |
| Timeout | Configured through WebDriverWait. | Configurable. |
| Polling | Handled by the wait implementation. | Polling interval can be customized. |
| Custom Conditions | Can be combined with custom lambda conditions. | Designed for custom waiting behavior. |
| Exception Handling | Depends on wait configuration. | Selected exceptions can be configured. |
| Condition | Meaning | Typical Use |
|---|---|---|
| Presence | Element exists in DOM. | DOM existence. |
| Visibility | Element is displayed. | Visible UI interaction. |
| Clickable | Element is visible and enabled. | Click operations. |
| Requirement | Condition |
|---|---|
| Element exists | presenceOfElementLocated() |
| Element is visible | visibilityOfElementLocated() |
| Button is ready to click | elementToBeClickable() |
| Loader disappears | invisibilityOfElementLocated() |
| Text appears | textToBePresentInElementLocated() |
| Attribute changes | attributeToBe() or attributeContains() |
| Checkbox is selected | elementToBeSelected() |
| Alert appears | alertIsPresent() |
| Frame becomes available | frameToBeAvailableAndSwitchToIt() |
| Old element is replaced | stalenessOf() |
| Title changes | titleContains() or titleIs() |
| URL changes | urlContains() or urlToBe() |
| New tab opens | numberOfWindowsToBe() |
Click Search
↓
AJAX Request
↓
Loading Spinner
↓
Wait for Spinner to Disappear
↓
Wait for Search Results
↓
Verify Results
↓
Continue Test
Open Login Page
↓
Wait for Username
↓
Enter Username
↓
Wait for Password
↓
Enter Password
↓
Wait for Login Button
↓
Click Login
↓
Wait for Dashboard
↓
Verify Dashboard
Open Product Page
↓
Wait for Product
↓
Wait for Add to Cart
↓
Click Add to Cart
↓
Wait for Cart Update
↓
Wait for Checkout
↓
Click Checkout
↓
Wait for Payment Page
↓
Verify Order
WebElement dropdown = wait.until(
ExpectedConditions.elementToBeClickable(
By.id("country")));
dropdown.click();
WebElement option = wait.until(
ExpectedConditions.elementToBeClickable(
By.xpath("//option[text()='India']")));
option.click();
driver.findElement(By.id("city"))
.sendKeys("Mum");
WebElement suggestion = wait.until(
ExpectedConditions.elementToBeClickable(
By.xpath("//li[contains(text(),'Mumbai')]")));
suggestion.click();
List<WebElement> rows = wait.until(
ExpectedConditions.visibilityOfAllElementsLocatedBy(
By.cssSelector("table tbody tr")));
for (WebElement row : rows) {
System.out.println(row.getText());
}
WebElement modal = wait.until(
ExpectedConditions.visibilityOfElementLocated(
By.id("modal")));
WebElement close = wait.until(
ExpectedConditions.elementToBeClickable(
By.id("closeModal")));
close.click();
wait.until(
ExpectedConditions.invisibilityOfElementLocated(
By.id("modal")));
driver.findElement(By.id("profile")).click();
wait.until(
ExpectedConditions.urlContains("/profile"));
wait.until(
ExpectedConditions.visibilityOfElementLocated(
By.id("profilePage")));
String parent = driver.getWindowHandle();
driver.findElement(By.id("open")).click();
wait.until(
ExpectedConditions.numberOfWindowsToBe(2));
for (String handle : driver.getWindowHandles()) {
if (!handle.equals(parent)) {
driver.switchTo().window(handle);
break;
}
}
driver.findElement(By.id("delete")).click();
Alert alert = wait.until(
ExpectedConditions.alertIsPresent());
System.out.println(alert.getText());
alert.accept();
wait.until(
ExpectedConditions.frameToBeAvailableAndSwitchToIt(
By.id("paymentFrame")));
driver.findElement(By.id("cardNumber"))
.sendKeys("123456");
driver.switchTo().defaultContent();
WebElement button = wait.until(
ExpectedConditions.visibilityOfElementLocated(
By.xpath("//button[@id='login']")));
button.click();
WebElement button = wait.until(
ExpectedConditions.elementToBeClickable(
By.cssSelector("#login")));
button.click();
WebElement username = wait.until(
ExpectedConditions.visibilityOfElementLocated(
By.id("username")));
If the test needs to interact with a visible element, DOM presence alone may not be sufficient.
wait.until(
ExpectedConditions.presenceOfElementLocated(
By.id("login")));
When visibility is required, use:
wait.until(
ExpectedConditions.visibilityOfElementLocated(
By.id("login")));
Visibility does not check whether an element is enabled. For a click operation, elementToBeClickable() can be more appropriate.
wait.until(
ExpectedConditions.elementToBeClickable(
By.id("submit"))).click();
Thread.sleep(5000);
driver.findElement(By.id("result")).click();
A condition-based approach is generally more suitable:
wait.until(
ExpectedConditions.elementToBeClickable(
By.id("result"))).click();
Extremely long timeouts can make failed tests slow to diagnose. Timeout values should be realistic for the application's expected response time and the test environment.
A very short timeout can produce false failures when the application normally requires more time because of network latency, server processing, or browser performance.
A test may fail when the selected condition does not represent the actual application state.
Need the element in DOM?
→ presenceOfElementLocated()
Need the element visible?
→ visibilityOfElementLocated()
Need the element ready for click?
→ elementToBeClickable()
Need the loader gone?
→ invisibilityOfElementLocated()
Expected Conditions cannot fix an incorrect or unstable locator. Stable IDs, data attributes, reliable CSS selectors, and carefully designed XPath expressions should be preferred.
Always determine the exact state required by the test before selecting an Expected Condition.
DOM Presence
↓
presenceOfElementLocated()
Visibility
↓
visibilityOfElementLocated()
Clickable State
↓
elementToBeClickable()
Disappearance
↓
invisibilityOfElementLocated()
Text State
↓
textToBePresentInElementLocated()
Attribute State
↓
attributeToBe() / attributeContains()
By loginButton =
By.cssSelector("[data-testid='login-button']");
wait.until(
ExpectedConditions.elementToBeClickable(
loginButton)).click();
In large automation frameworks, reusable wait utilities reduce duplicated synchronization code and make the framework easier to maintain.
Synchronization logic can be maintained inside Page Object methods so that test cases focus on business workflows and validations.
Instead of waiting for an arbitrary number of seconds, wait for the actual condition that indicates the application is ready.
Do not add explicit waits before every Selenium command. Use synchronization where the application has asynchronous or dynamic behavior that requires it.
Timeouts should provide enough time for expected application behavior without unnecessarily delaying failed tests.
| Condition | Purpose |
|---|---|
| presenceOfElementLocated() | Wait for DOM presence. |
| visibilityOfElementLocated() | Wait for visible element. |
| visibilityOf() | Wait for an existing element to become visible. |
| elementToBeClickable() | Wait for visible and enabled element. |
| invisibilityOfElementLocated() | Wait for element to disappear or become invisible. |
| textToBePresentInElementLocated() | Wait for specific text. |
| textToBePresentInElement() | Wait for text in an existing element. |
| attributeToBe() | Wait for exact attribute value. |
| attributeContains() | Wait for partial attribute value. |
| elementToBeSelected() | Wait for selected element. |
| elementSelectionStateToBe() | Wait for selected/unselected state. |
| alertIsPresent() | Wait for JavaScript alert. |
| frameToBeAvailableAndSwitchToIt() | Wait for frame and switch into it. |
| stalenessOf() | Wait for old element to become stale. |
| titleContains() | Wait for title text. |
| titleIs() | Wait for exact title. |
| urlContains() | Wait for URL text. |
| urlToBe() | Wait for exact URL. |
| numberOfWindowsToBe() | Wait for required window count. |
Answer: Expected Conditions are predefined Selenium conditions used with explicit waits to synchronize test execution with specific application states such as visibility, presence, clickability, text, attributes, alerts, frames, windows, titles, URLs, and selection.
Answer: They are used to synchronize automation scripts with dynamic web applications and reduce failures caused by timing differences between Selenium commands and application state changes.
Answer: It waits until an element is present in the DOM. It does not require the element to be visible.
Answer: It waits until an element is located and is visible on the page.
Answer: It waits until an element is visible and enabled, making it suitable for many click operations.
Answer: No. Overlays, animations, layout changes, stale elements, or other application behavior can still interfere with an actual click.
Answer: It waits until an element becomes invisible or is no longer present according to the condition's behavior.
Answer: It waits until a JavaScript alert is present and returns the Alert object.
Answer: It waits until a previously located WebElement is no longer attached to the current DOM.
Answer: It waits for a frame to become available and automatically switches the WebDriver context into that frame.
Answer: Yes. Conditions such as presence, visibility, clickability, text, attribute changes, selection, and invisibility are useful for dynamic elements.
Answer: Yes. Expected Conditions can be used with XPath through By.xpath().
wait.until(
ExpectedConditions.visibilityOfElementLocated(
By.xpath("//button[@id='login']")));
Answer: Yes. CSS selectors can be passed through By.cssSelector().
wait.until(
ExpectedConditions.elementToBeClickable(
By.cssSelector("#login")));
Answer: If the condition is not satisfied within the configured timeout, the explicit wait fails with a TimeoutException.
A Selenium e-commerce automation project can use Expected Conditions throughout the complete workflow.
Launch Browser
↓
Open Application
↓
Wait for Login Form
↓
Enter Credentials
↓
Wait for Login Button
↓
Click Login
↓
Wait for Dashboard
↓
Search Product
↓
Wait for Search Results
↓
Select Product
↓
Wait for Product Page
↓
Add to Cart
↓
Wait for Cart Update
↓
Wait for Checkout
↓
Complete Checkout
↓
Wait for Confirmation
↓
Validate Order
presenceOfElementLocated() when DOM presence is sufficient.visibilityOfElementLocated() when visibility is required.elementToBeClickable() before many click operations.invisibilityOfElementLocated() for loaders and temporary overlays.alertIsPresent() for JavaScript alerts.stalenessOf() when an old DOM element is replaced.Thread.sleep().Expected Conditions are an important part of Selenium synchronization and explicit waits. They allow automation scripts to wait for specific application states instead of relying on arbitrary fixed delays.
The most commonly used conditions include presenceOfElementLocated(), visibilityOfElementLocated(), visibilityOf(), elementToBeClickable(), invisibilityOfElementLocated(), textToBePresentInElementLocated(), attributeToBe(), attributeContains(), elementToBeSelected(), alertIsPresent(), frameToBeAvailableAndSwitchToIt(), stalenessOf(), titleContains(), urlContains(), and numberOfWindowsToBe().
The key to effective Selenium synchronization is selecting the condition that represents the actual state required by the test. Presence, visibility, clickability, selection, text, attributes, alerts, frames, URLs, and windows are different states and should be handled with the appropriate Expected Condition.
Learn Selenium WebDriver, Java automation, locators, WebElements, waits, synchronization, dynamic elements, TestNG, Page Object Model, framework development, and real-world automation testing through the Selenium Training Course.
For a course demonstration, visit the Selenium Course Demo.
